CI CD Using Github and Microservices Development in Python

Open a New Chrome Web Browser Tab/Window using either the main Ubuntu Applications menu located at the top of your desktop, or the Ubuntu Desktop Launcher located at the bottom of your desktop as seen in the two images below:

Navigate to “https://github.com/”

Click on "Sign up" and follow the instructions to create a new account.

Once you have completed the account registration, verified your email, and tested logging into your new personal GitHub account, proceed to Part 3.

Log into your Personal GitHub Account.

Access GitHub account settings by clicking on your profile picture located in the top-right corner and selecting "Settings".

In the left sidebar-menu, locate and click on "Developer settings" (typically located at the bottom of the menu).

Select "Personal access tokens".

Select “Tokens (classic)”.

Click on "Generate new token (classic)" button.

Assign your token a description in the “note” field, for example “wa2917 PAT”.

For the “Select scopes” field select "repo" for full control of private repositories, and also select “workflow” to allow updating of Github Action workflows as seen below:

Click on "Generate token", usually located at the bottom of the screen.

Immediately copy the token by clicking on the copy-icon (we will save this token in a moment).

If you make a mistake, then you can delete the token, and create another one. We will be using the token later in this lab, and during future labs.

We will now create a new text file and save it on the Desktop, to store our token for re-use when needed. We will do this using Visual Studio Code (VSCode) as outlined in the next few steps.

Open a New Terminal using the “Terminal” icon in the main Ubuntu Desktop Launcher as shown below.

Create a new file in VSCode by entering the following command.

code ~/Desktop/my_tokens.txt

Enter a new line and a label/comment to identity the token such as:

github:

Press enter to append a new line after the label.

Using the right-mouse context-menu paste option, “Paste” your token into the new file as in the example image below:

Remember, each OS (Windows, MacOS etc) have different supported copy/paste shortcut commands.

The result will be similar to the image below:

Save the file using the VSCode File > Save menu-option, then use File > Exit to close VSCode.

Well done! The lab is complete.

Close all open Terminal sessions.

Close all open Web Browser windows.

Close all open VSCode files & windows.

We are now ready to use GitHub for working with Repositories and GitHub Actions.

Open a New Chrome Web Browser Tab/Window using either the main Ubuntu Applications menu located at the top of your desktop, or the Ubuntu Desktop Launcher located at the bottom of your desktop as seen in the two images below:

Sign in to your Personal GitHub Account.

In GitHub, click on your Profile icon on the top-right hand corner of the GitHub user-interface and select “Your repositories” from the list of menu options.

To create a new repo, you can click the “New” button or look for the “+” icon in the upper-right side of the GitHub user-interface. Either of these options will present the new repo wizard.

You can see these options highlighted in the image below:

Give your repository a name. Enter “github-lab1” in the “Repository name” field.

github-lab1

Write a brief description of your repository in the “Description” field for example “GitHub Lab 1”.

GitHub Lab 1 testing

Set your repository to be Private (only you and people you invite can see it).

Locate the “Initialize this repository with README” section and check the “Add a README file” option, which will automatically create a README file in your repository.

Check your settings match those of the image below:

Click “Create repository” to finish.

You will then be taken to the github-lab1 repository home-page as shown below:

Use the Existing Terminal session you opened earlier, or create a New Terminal session if you have closed it.

Create a new working folder called “Works” in your user’s home directory, using the following commands:

cd /home/wasadmin/
mkdir Works
cd /home/wasadmin/Works

Check you are in the “/home/wasadmin/Works” folder using the “print working directory (pwd)” command:

pwd

Result:

/home/wasadmin/Works

Return to the existing GitHub interface browser window - “github-lab1” repo’s home page.

Click the button labeled “<> Code” and from the dialog box copy the “HTTPS” URL. It will be in the format of “https://github.com/<github-username>/github-lab1” as seen below:

Now you can issue a “git clone <URL>” command in your Terminal session using the repo HTTPS URL that you copied above.

Use the right-mouse context-menu, paste option to paste the URL into the terminal after the command “git clone“, to complete the full command below:

git clone <pasted repo URL>

We can see the use of right-mouse paste context menu below:

The completed full-command syntax including the repo (HTTPS) URL will be as follows:

git clone https://github.com/<your_github_username>/github-lab1.git

If you have issues with right-mouse-paste, then you can you can type out the full command, making sure that you use the correct GitHub username in the URL.

When prompted for your username, use your GitHub username, not your GitHub email.

For the password we will copy your previously stored Personal Access Token (PAT) from “my_tokens.txt” which should have been saved on your Lab machine’s desktop from a previous lab.

Open “my_tokens.txt” by double-clicking on it.

For the password, copy your saved Personal Access Token (PAT) from the my_tokens.txt”, and paste it in the Terminal session, to complete the “git clone” command as seen in the image below:

This is a security measure to hide the password from prying eyes.

The result will be similar to the following output:

git clone https://github.com/<your_github_username>/github-lab1.git
Cloning into 'github-lab1'...
remote: Enumerating objects: 3, done.
remote: Counting objects: 100% (3/3), done.
remote: Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
Receiving objects: 100% (3/3), done.

Use the ”ls” command to view the contents of the “Works” folder, which will now contain the cloned repo:

ls -ltra

Result:

drwxr-x--- 21 wasadmin wasadmin 4096 Jul 3 15:34 ..
drwxrwxr-x 3 wasadmin wasadmin 4096 Jul 3 15:58 .
drwxrwxr-x 3 wasadmin wasadmin 4096 Jul 3 15:58 github-lab1

Using the “tree” command check the contents of the “github-lab1” folder:

tree github-lab1

The result will be similar as seen in the output below:

github-lab1
└── README.md

0 directories, 1 file

You should see that we have the “README.md” that was automatically created for us by the new repo wizard earlier in GitHub.

First navigate into the repo:

cd github-lab1

Inside the cloned repository’s root directory, run the following commands to configure an example “local” Git identity for the repo:

git config user.name "Bob"
git config user.email "bob@example.com"

In a real-life scenario, you can set your actual name, and email.

It is also possible to set this globally for all repos using the “--global” switch.

Type the following command to view your git configuration has been successful.

git config --local --list

Result will be a similar output to the following:

core.repositoryformatversion=0
core.filemode=true
core.bare=false
core.logallrefupdates=true
remote.origin.url=https://github.com/<your_github_username>/github-lab1.git
remote.origin.fetch=+refs/heads/:refs/remotes/origin/
branch.main.remote=origin
branch.main.merge=refs/heads/main
user.name=Bob
user.email=bob@example.com

It is possible to set settings in both Git and GitHub if you wish to use “master” as trunk instead of “main”.

Open a new Terminal session (or use and existing Terminal session) on your lab machine.

Run the following command to configure your Git credentials:

git config --global credential.helper store

The token will be cached in a file called “~/.git-credentials” so future calls to GitHub will no longer require authentication.

Issue the “git pull” command to force a re-authentication and save your GitHub credentials into the store.

git pull

The result will be a prompt for your GitHub username and PAT as we did earlier.

If prompts for, Login using your GitHub username, not your GitHub email. For the password use your Personal Access Token (PAT) from “my_tokens.txt” which should have been saved on your Lab machine’s desktop from a previous lab.

Confirm your credentials have been stored as plain text using the cat command:

cat ~/.git-credentials

The result will be text similar to the following output:

Now, when you interact with remote repositories hosted on GitHub, Git will automatically use the stored credentials (PAT) for authentication.

It is recommended to use a more secure method of authentication, such as password protected SSH keys or third-party credential managers, if possible.

Run the following command to create a new branch for your feature development:

git checkout -b feature/my-feature

Result:

Switched to a new branch 'feature/my-feature'

Use the “git branch” command to list current branches, and display the active branch:

git branch

The result will be as follows:

* feature/my-feature
main

Using VSCode, create a new file called “index.html” using the VSCode command-line tool as follows:

code index.html

Paste in the following HTML code into the “index.html” in VSCode.

<html>
    <head>
        <title>This is the title of the webpage!</title>
    </head>
    <body>
        <p>This is an example paragraph. Anything in the <strong>body</strong> tag will appear on the page, just like this <strong>p</strong> tag and its contents.</p>
    </body>
</html>

The resulting “index.html” file should look the same as in the image below:

Save the file using the VSCode menu option: File > Save then exit VSCode using File > Exit in the main VSCode menu.

Verify that you have created “index.html”, by printing it to the screen using the “cat” command as follows:

cat index.html

Check the status of the repo using the following command:

git status

The result will be as follows:

On branch feature/my-feature
Untracked files:
  (use "git add <file>..." to include in what will be committed)
	index.html

nothing added to commit but untracked files present (use "git add" to track)

Use the following commands to stage and commit your changes:

git add index.html
git commit -m "Implement my feature"

Push the new feature branch to GitHub using the following git command:

git push origin feature/my-feature

The result of the “git push” will look similar to the output below:

git push origin feature/my-feature
Enumerating objects: 4, done.
Counting objects: 100% (4/4), done.
Delta compression using up to 4 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 437 bytes | 437.00 KiB/s, done.
Total 3 (delta 0), reused 0 (delta 0), pack-reused 0
remote:
remote: Create a pull request for 'feature/my-feature' on GitHub by visiting:
remote: https://github.com/<your_github_username>/github-lab1/pull/new/feature/my-feature
remote:
To https://github.com/<your_github_username>/github-lab1.git
* [new branch] feature/my-feature -> feature/my-feature

We will now complete the rest of the flow in the GitHub Interface.

In the existing open Chrome Web Browser window make sure you are in the GitHub interface:
https://github.com/

Open the main repositories page, but clicking on your GitHub profile-icon in the top right-hand corner of the GitHub interface, and selecting “Your repositories” as seen below:

To load the “github-lab1” home page, locate and click on the “github-lab1” repo link from the repository list.

Click on the "Pull requests" tab, as seen in the image below.

Click on the "New pull request" button.

Select the “main” branch of the original repository as the “base” branch, and select your new feature branch (“feature/my-feature”) as the “compare” branch as seen in the example images below:

As we can see in the image below, the feature branch contains our recent changes, and so there is a difference (delta) between the “main” branch and the “feature/my-feature” branch.

This is where we create a pull request which will allow collaborators to review and ultimately decide to allow a merge request or not?

Click on "Create pull request".

In the open a pull request screen, complete the body of the request, by typing:

Please review :-)

Once the comment has been added, click the “Create pull request” button again to action the request.

The page will load and merge options are presented as seen below:

We are now ready to decide how we wish to merge?

Click the “Merge pull Request” button for the pending pull requests seen below:

The interface will update to present the “Confirm merge” option, where it is possible to update the commit message as seen below:

Leave the commit message as is for consistency, and Click on the “Confirm merge” button.

The interface will update again with the results of the merge as seen below:

We will now make sure our local repo is updated by checking-out the “main” branch, and issuing a git pull to receive the changes from the recent merge of the “feature/my feature” branch to the “main” branch.

Switch to your existing Terminal session, and issue the following git command to check out the “main” branch:

git checkout main

Result:

Switched to branch 'main'
Your branch is up to date with 'origin/main'.

Issue the “git pull” command to receive the changes from GitHub

git pull

The result will be similar as seen in the following image:

The main branch of local clone is now up to date. We can issue the “git branch” command to confirm which branch is currently the active branch.

Display the active branch using the “git branch” command:

git branch

The result will show that the active branch is “main” denoted by the asterisk (“*”) as seen in the output below:

feature/my-feature
* main

Congrats, you have completed a Pull Request, and subsequent Merge using the GitHub Interface.

In the current open Terminal session and checkout the “feature/my-feature” branch again using the “git checkout” command as follows:

git checkout feature/my-feature

Result:

Switched to branch 'feature/my-feature'
Your branch is up to date with 'origin/feature/my-feature'.

Set the upstream branch for the local branch "feature/my-feature" to the remote branch "origin/feature/my-feature" using this command below.

git branch --set-upstream-to=origin/feature/my-feature feature/my-feature

To ensure we are synchronized with the origin, execute the "git pull" command as follows:

git pull

Open the “index.html” file again, using the VSCode command-line tool:

code index.html

Edit the “index.html” file to change the HTML Title text from “This is the title of the webpage!” to the following:

My Web Application

The result will be as follows:

Save “index.html” using File > Save, then use exit VSCode usingFile > Exit in the VSCode menu.

Issue the “git status” command to see the state of the working tree:

git status

Result:

git status
On branch feature/my-feature
Your branch is up to date with 'origin/feature/my-feature'.
Changes not staged for commit:
(use "git add <file>..." to update what will be committed)
(use "git restore <file>..." to discard changes in working directory)
modified: index.html
no changes added to commit (use "git add" and/or "git commit -a")

Stage (add) all the changes in the current directory, and commit using the following commands:

git add .
git commit -m "Updated Title"

Result:

[feature/my-feature a15b7d3] Updated Title
1 file changed, 1 insertion(+), 1 deletion(-)

Push the changes to Github (origin)

git push

Result:

Enumerating objects: 5, done.
Counting objects: 100% (5/5), done.
Delta compression using up to 4 threads
Compressing objects: 100% (3/3), done.
Writing objects: 100% (3/3), 321 bytes | 321.00 KiB/s, done.
Total 3 (delta 1), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (1/1), completed with 1 local object.
To https://github.com/<your_github_username>/github-lab1.git
916f15d..a15b7d3 feature/my-feature -> feature/my-feature

Go to Github interface which should be still open in a browser window, locate and navigate to the “github-lab1” home page.

Click on the "Pull requests" tab.

Click the New pull request button.

Change the compare branch to “feature/my-feature”

Click the “Create pull request” button.

The interface will update and you will be presented with the “Comparing changes”. And this time you will see the “delta” modifications as seen in the image below:

Add a comment as follows:

Review the title change

Click the “Create pull request” button again to action the creation of the Pull Request.

The result will be the presentation of the Merge page as seen below:

This time we will not use GitHub to initiate the Merge, we will instead do this from the command-line in our local clone of repo.

Open your existing Terminal session and issue the following commands:

git config pull.rebase false
git pull origin main

You will be presented with a command-line editor (nano) asking for you to confirm the commit message. We do not need to change the merge commit-message, so use CTRL-X to save and leave the nano editor:

The resulting output message will be as follows:

* branch main -> FETCH_HEAD
Merge made by the 'ort' strategy.

Enter the following massages:

git checkout main
git merge --no-ff feature/my-feature

You will be presented with a command-line editor (nano) asking for you to confirm the commit message as seen below:

We do not need to change the merge commit-message, so use CTRL-X to save and leave the nano editor:

The resulting output message will be as follows:

Merge made by the 'ort' strategy.
index.html | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)

Check the status again:

git status

Result:

On branch main
Your branch is ahead of 'origin/main' by 3 commits.
(use "git push" to publish your local commits)
nothing to commit, working tree clean

Push the merged changes to update the “main” branch in GitHub (origin).

git push -u origin main

The resulting output will be similar to below:

Enumerating objects: 2, done.
Counting objects: 100% (2/2), done.
Delta compression using up to 2 threads
Compressing objects: 100% (2/2), done.
Writing objects: 100% (2/2), 376 bytes | 376.00 KiB/s, done.
Total 2 (delta 1), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (1/1), done.
To https://github.com/<your_github_username>/github-lab1.git
69ce66b..49d75f6 main -> main
Branch 'main' set up to track remote branch 'main' from 'origin'.

Congrats, You have now successfully set up a Git Repo, created a feature branch, completed a pull request and merged code, thus following the essentials of the GitHub Flow workflow.

Using an Existing or New Chrome browser window, open the GitHub interface:

Navigate to the “github-lab1” repository on GitHub

Once on the “github-lab1” repository home page, open the branches page, by clicking on the branches icon as shown below:

In the “branches” page, click on the “feature/my-feature” branch to display the contents of the branch as shown below:

You will be taken to the home page of the “feature/my-feature” branch as seen below:

To investigate the branch commit history, click on the “History” link as shown below:

You will then be taken to the commits page of the “feature/my-feature” branch as seen below:

To view the actual commit labeled with the commit message “Updated Title”, click on the commit message label as shown in the image above.

The result will be details page for the commit. In this page, we can see the actual change made as seen in the image below:

As you can see, GitHub has a very intuitive interface designed for easy, and simple use.

Navigate back to the “github-lab1” repo using the main link in the tab-menu as shown below:

At this point we are done navigating around the “feature/my-feature” branch.

Congratulations on finishing the fundamental aspects of GitHub Workflow; however, you have only witnessed a fraction of its functionalities, and as you continue to utilize GitHub for your projects, you will discover and adopt new approaches to enhance your experience.

Close all open Terminal sessions.

Close all open Web Browser windows.

Close all open VSCode files & windows.

Close all unused terminal sessions from any previous labs, then create a New Terminal session.

Create a new folder called “lab3” which is located at “/home/wasadmin/Works/lab3” using the following commands:

mkdir -p /home/wasadmin/Works/lab3

Navigate to the folder using the “change directory (cd)” command:

cd /home/wasadmin/Works/lab3

Launch VSCode to open using the current folder as the working directory

code .

Create a new file called “##my_app.py” using the new file icon in the file-explorer as shown below:

Copy & paste in the following code into “my_app.py”, and save the file using File > Save using the VSCode menu.

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run()

Have a read of the code in “my_app.py”

Unlike many other programming languages that use braces or keywords to delineate blocks of code, Python uses indentation to determine the grouping and nesting of statements. In Python, indenting is a fundamental aspect of the language’s syntax and is used to define the structure and organization of code blocks.

This code is using an indentation of 4 spaces for each level of indent, make sure that your code matches the image below:

Explanation of the “my_app.py” Python code

This basic Flask application defines a single default route ("/") and returns a "Hello, World!" message. Let’s break down the code:

Importing the necessary module:

from flask import Flask imports the Flask module, which provides the necessary functions and classes to create and run a Flask application.

Creating the Flask application instance:

app = Flask(name) creates an instance of the Flask class and assigns it to the variable app. The “name” parameter is a special Python variable that represents the name of the current module.

Defining a route and view function:

@app.route('/') is a decorator that tells Flask to associate the following function with the root URL ('/'). In this case, the function is hello().

def hello(): is a view function that will be executed when a request is made to the specified route ('/'). It returns the string 'Hello, World!'.

Running the application:

if name == "main": is a condition that checks if the script is being executed directly (not imported as a module).

app.run() starts the Flask development server, allowing the application to handle incoming requests.

Save the file.

Close the “my_app.py” using the VSCode menu: File > Exit.

In your Existing Terminal session, navigate to the “lab3” working folder:

cd /home/wasadmin/Works/lab3

Install the Flask dependency which is required to run a flask application:

pip install Flask==2.3.2

Run the flask app using the following command:

python my_app.py

The Flask development server will start as seen below:

Using the Chrome (or Firefox) launcher located on the Desktop, or the using the main Ubuntu Applications menu, open a New Browser window and navigate to http://localhost:5000.

You should see the message "Hello, World!" displayed on the page as shown below:

Close the Browser window.

Stop the Flask development server by using CTRL+C in the Terminal session where the app is running.

Using any open terminal navigate to “/home/wasadmin/Works/lab3”

cd /home/wasadmin/Works/lab3

Open VSCode, into the current folder and create a new file called “requirements.txt” using the exact same process we used earlier to create the “my_app.py” file.

code .

Copy and paste in the following code:

Flask==2.3.2
# Add other dependencies as needed

The result should be the same as the image below:

Save the “requirements.txt” file using File > Save, and exit VSCode using File > Exit.

Run the following command to which version of python is being used.

python --version

Result:

Python 3.10.4

Lets uninstall the existing flask dependency we installed earlier by using the following command:

pip uninstall flask==2.3.2 -y

Install the Flask dependency again, but this time using “pip” and the “requirements.txt” file by using the following command:

pip install -r requirements.txt

The result will be as follows - "Successfully installed Flask":

We will now move on to learn how we can run Flask applications in various ways.

Launch VSCode and create a new file called “run.py” in the same folder as “my_app.py”

code .

Copy and paste in the following Python code:

from my_app import app

if __name__ == '__main__':
    app.run()

Check that the new “run.py” file contains the same code as depicted below:

Save the file using File > Save, and exit VSCode using File > Exit

In the same Terminal session as you used earlier, run your Flask application using the wrapper by executing the following command:

python run.py

As before, using the Chrome (or Firefox), open a New Browser window and navigate to http://localhost:5000.

You should see the message "Hello, World!" displayed on the page as before.

Once you have verified that the app is running using the wrapper approach which uses “run.py”, close the Browser window.

Stop the development server by using CTRL+C in the Terminal session where the app is running.

Launch VSCode using the command:

code .

Create a new file called “test.py” in the same location as “my_app,py”.

Copy and Paste in the following Python code:

import unittest
from my_app import app

app.testing = True

class FlaskTests(unittest.TestCase):
    def test_hello(self):
        client = app.test_client()
        response = client.get('/')
        self.assertEqual(response.status_code, 200)
        self.assertEqual(response.data.decode('utf-8'), 'Hello, World!')

if __name__ == '__main__':
    unittest.main()

Make sure that “test.py” contains all the code, with the correct indentations, and looks like the code shown below:

Save the file using File > Save, and exit VSCode using File > Exit

Explanation of test.py

In summary, the code in “test.py” sets up a test case for a Flask application and defines a single test method that checks if the root URL of the application returns a response with a status code of 200 and the content 'Hello, World!

Here is a break down of the contents of “test.py”, explaining what the code is doing:

Breakdown of “test.py”

The code imports the unittest module, which is a framework for writing and running tests in Python.

It also imports the app object from a module called my_app. This suggests that there is a Flask application defined in that module.

The line app.testing = True sets a flag in the Flask app object to indicate that the application is being tested.

The code defines a class called FlaskTests, which inherits from unittest.TestCase. This means that it’s a test case class that can contain individual test methods.

Inside the FlaskTests class, there is a single test method called test_hello. Test methods in unittest are identified by their names starting with the word "test". This method will test a specific functionality of the Flask application.

Within the test_hello method, it creates a client object by calling app.test_client(). This client object allows us to send HTTP requests to the Flask application.

It then sends a GET request to the root URL ("/") of the application using client.get('/').

The response object contains the server’s response to the request. The code uses assertions to check if the response is as expected.

The line self.assertEqual(response.status_code, 200) checks if the response status code is 200, which indicates a successful request.

The line self.assertEqual(response.data.decode('utf-8'), 'Hello, World!') checks if the response data, decoded as UTF-8, is equal to the string 'Hello, World!'.

Finally, the code checks if the script is being run directly (not imported as a module) using if name == 'main', and if so, it runs the tests using unittest.main().

Run the Unit Test

We are now going to create a bash script to run the Unit Test. This script could be used in a CI/CD pipeline.

Using your current terminal session, create a new file called “run_test.sh” using the touch command:

touch /home/wasadmin/Works/lab3/run_test.sh

Using the command-line, launch VSCode and automatically open the new (empty) “run_test.sh” file using the following command:

code /home/wasadmin/Works/lab3/run_test.sh

Copy and Paste the following bash script into “run_test.sh”:

!/bin/bash
python -m unittest test.py

The “run_test.sh” script should look exactly as depicted in the image below:

Save the “run.test.sh” file using File > Save, and then exit VSCode using File > Exit.

Run the Unit Test by executing the following command:

source run_test.sh

The result will be similar to the following output:

.
----------------------------------------------------------------------
Ran 1 test in 0.006s

OK

We can see that the test has run successful.

Explanation of the contents of “test_run.sh”

The “-m” switch is a command-line option for running a Python module as a script. It allows you to execute a module directly without specifying the file path explicitly.

For example, when you use “python -m unittest test.py”, the “-m” switch treats unittest as a module and ”test.py” as the script to be executed within that module.

We will create more unit tests using various approaches in subsequent labs.

The lab is now complete.

Close all open Terminal sessions.

Close all VSCode files, and windows.

Close all open Web Browser windows.

Close all existing open Terminal sessions from previous labs.

Open a new Terminal session.

Navigate to the “/home/wasadmin/Works” directory using the following command:

cd /home/wasadmin/Works

Create the “lab4” directory and change into it using the following single-line command sequence:

mkdir lab4 && cd lab4

Create directory structure for storing the Python Project code:

mkdir -p MyProject/my_greeting_app

“MyProject” is the name of your project. It’s the base directory you will use for storing your project files.

“my_greeting_app” is the custom Python package name.

Verify the current folder structure using the “tree” command:

tree

The result should be similar to the following output:

.
└── MyProject
└── my_greeting_app

2 directories, 0 files

Switch to “MyProject” directory:

cd MyProject

Use the “Print Working Directory (pwd)” command to show the current directory:

pwd

Result should be:

/home/wasadmin/Works/lab4/MyProject

Create “greeter.py” by using the Visual Studio (VSCode) command line shortcut:

code my_greeting_app/greeter.py

Enter following code:

class Greeter:
def say_hello(self):
return "Hello, Planet Earth!"

Check that your code as the correct indentation as shown below:

Save the “greeter.py” file using File > Save, and then exit VSCode using File > Exit.

In a similar fashion, create “app.py” file using the VSCode command-line shortcut:

code my_greeting_app/app.py

Copy and Paste the following code into “app.py”:

from flask import Flask
from my_greeting_app.greeter import Greeter
import os

def create_app():
    app = Flask(__name__)
    greeter = Greeter()

    @app.route('/')
    def hello():
        greeting = greeter.say_hello()
        return greeting
    return app

if __name__ == '__main__':
    app = create_app()
    app.run()

The “app.py” file should contain the code, and have the exact same indentations as shown in the image below:

Save the “app.py” file using File > Save, and then exit VSCode using File > Exit.

Create an empty “init.py” file using the touch command to make the folder a module.

touch my_greeting_app/__init__.py

View and validate that you have the correct directory structure using the tree command:

tree

Result:

.
└── my_greeting_app
    ├── __init__.py
    ├── app.py
    └── greeter.py

1 directory, 3 files

Verify that “pyenv” is installed using the commands:

pyenv global 3.10.4
pyenv version

The resulting reported python version should be “3.10.4”

Now, install another specific version of Python (version 3.10.7) using the ”PyEnv” command as follows:

pyenv install 3.10.7

If you choose “y” then be patient, the installation process can take a few minutes.

We require “3.10.7” as the default version of Python from now on, so set PyEnv to use version 3.10.7 by issuing the following commands:

pyenv local 3.10.7
pyenv version

The reported python version should now be “3.10.7”

Check the contents of the .python-version file using the “cat” command:

cat .python-version

Result:

3.10.7

Verify that the “pyenv-virtualenv plugin” is installed:

pyenv virtualenv --version

Result:

pyenv-virtualenv 1.2.1 (python3.10 -m venv)

Create a new Python virtual environment using “pyenv” by running the following command:

pyenv virtualenv 3.10.7 myproject-env

View the list of Pyenv managed Virtual Environments using the following command:

pyenv virtualenvs

The result will look something like:

To use a specific virtual environment we need to activate it.

Activating the virtual environment ensures that the subsequent commands and installations are performed within the virtual environment, and not in the global python installation.

Activate the virtual environment using the following command:

pyenv activate myproject-env

Your terminal session prompt will now show the activated virtual environment as seen in the image below:

Using VSCode command-line shortcut create a new file called “requirements.txt”:

code requirements.txt

Enter following single line of code, to specify the required “Flask" dependency:

Flask

Save the newly created “requirements.txt” file using File > Save, and then exit VSCode using File > Exit.

Verify the folder structure using the “tree” command:

tree

The result should match the following output:

.
├── my_greeting_app
│   ├── __init__.py
│   ├── app.py
│   └── greeter.py
└── requirements.txt

1 directory, 4 files

Install the dependencies listed in the “requirements.txt” file using “pip”:

pip install -r requirements.txt

You have now installed Flask version 2.3.2 into the virtual environment.

In the next part, we will continue on and run the application.

Run the Flask application using the Python interpreter set by the virtual environment

python -m my_greeting_app.app

Verify the application is running by opening a new browser window (Using Chrome or Firefox) and navigating to http://localhost:5000/ or http://127.0.0.1:5000/

The result will be as shown in the image below:

Once you have verified that the application is running in the Flask Development Server and functioning as expected, locate the Terminal window where the Flask application is running, then issue CTRL-C in the Terminal to close the running flask application.

The Flask Command-line Tool

We will try another method (“flask run”)

In the same Terminal session, set the Flask app’s entry point by setting the “$FLASK_APP” environment variable:

export FLASK_APP=my_greeting_app/app.py

Now, run the flask app using the flask command-line tool:

flask run

Verify the application is running by opening a new browser window (Using Chrome or Firefox) and navigating to http://localhost:5000/ or http://127.0.0.1:5000/.

Exit the app after you see it running the second time using “CTRL-C”.

CTRL-C

Comparing the two approaches

The reason to use different methods to run a Flask app, is to provide flexibility and accommodate different use cases.

Let’s explore the reasons for using each method:

Running the Flask application using the Python interpreter:

Open the existing “requirements.txt” file using VSCode command-line tool:

code requirements.txt

At the end of the file, append the following line:

pytest==7.3.2

The resulting update to “requirements.txt” will look exactly like the image below:

Save the “requirements.txt” file, and Exit VSCode.

Using the command-line, check that the file has two dependencies using the “cat” command.

cat requirements.txt

Result:

Flask
pytest==7.3.2

Using Pip, install the new dependencies into the virtual environment as specified in “requirements.txt”:

pip install -r requirements.txt

We are now ready to create and run a Unit Test.

Check that you are in the correct folder “/home/wasadmin/Works/lab4/MyProject” using the pwd command:

pwd

Result:

/home/wasadmin/Works/lab4/MyProject

Create a tests directory to contain Unit Tests:

mkdir tests

Copy the sample template unit test files from “/home/wasadmin/Student_Templates/lab4/MyProject/tests” into the tests folder using the following command:

cp -r /home/wasadmin/Student_Templates/lab4/MyProject/tests/* tests

Using the tree command verify that you have two new files in the test folder:

tree

You should now see a folder structure as follows:

.
├── my_greeting_app
│   ├── __init__.py
│   ├── __pycache__
│   │   ├── __init__.cpython-310.pyc
│   │   ├── app.cpython-310.pyc
│   │   └── greeter.cpython-310.pyc
│   ├── app.py
│   └── greeter.py
├── requirements.txt
└── tests
├── __init__.py
└── test_hello.py

3 directories, 9 files

Open the “test_hello.py” file, and have a quick read through.

code tests/test_hello.py

An Explanation of “test_hello.py”

Importing necessary modules:

Close the “test_hello.py” file using VSCode menu option: File > Exit.

Change to the my_greeting_app folder.

cd my_greeting_app

Run the test by issuing the “pytest” command as follows:

pytest

The result will be a failed test as seen below:

If we look closely as the AssertionError we can see that the test failed because the app code outputs “Hello, Planet Earth!” but the test is looking for “Hello, World!”. We will now fix the test.

Open “test_hello.py” using the VSCode command-line:

code /home/wasadmin/MyProject/tests/test_hello.py

Change the Unit Test code to test for “Hello, Planet Earth!” instead of “Hello, World!”. To do this comment out the existing line by adding a “#” at the beginning of the existing line and add a new line “assert res.data == b’Hello, Planet Earth!'” as shown below:

Save the file using File > Save, and Exit VSCode using File > Exit

Re-run the test using the “pytest” command in the my_greeting_app folder:

pytest

The result will be a successful as shown below:

How did the “pytest” command know where to find the test?

Pytest follows certain conventions to discover and run tests. In the lab you provided, the test file is named “test_hello.py”. The naming convention test_*.py helps “pytest” automatically recognize the file as a test module.

When you run “pytest” from the command line in the directory containing your tests, it automatically scans for files matching the test file naming pattern and collects all the test functions within those files.

Here’s a breakdown of how Pytest discovers the tests:

File Naming Convention:

Install the “pytest-html” Plugin, using the pip command as follows:

pip install pytest-html

Generate the HTML report by running the following command:

pytest --html=report.html

The result will be generated report in a file called “report.html” as seen below:

Once the command is executed successfully, you can navigate to the file system using a file explorer, locate the “report.html” file, and open it in a web browser to view the generated HTML report with the detailed test results.

Open the File-Explorer app using the Desktop Launcher as seen below:

Navigate to the “Home/Works/lab4/MyProject folder as seen below:

To view the generated Unit Test report, open the “report.html” file using the right-mouse click option, and select “Open With Google Chrome” as shown in the image below:

The result will be as follows:

In conclusion, generating HTML reports for unit tests using the "pytest-html" plugin is an essential step in the development process. By installing the plugin and executing the appropriate command, you can obtain a detailed report that provides insights into the test results.

The lab is complete.

Close all open Terminal sessions.

Close all open Web Browser windows.

Close all open VSCode files & windows.

Log into your personal GitHub account which you are using for this lab.

Navigate to the main "Dashboard” (https://github.com/dashboard) of your GitHub account. You do this by clicking on the Dashboard link in the main top navigation toolbar as seen below:

or, by using the left-hand-side hamburger menu as seen below, and selecting “Home”.

Either use the global quick toolbar "+" "button, or from the left-hand-side menu choose the "New" button, or if shown “Create a new repository” button, as seen in the image below.

In the "Create a new repository" page (https://github.com/new) enter the following name for the Repository:

github-actions-lab5

Add a description for the repo, such as:

Lab 5 GitHub Actions

Choose “Private” repo.

Click "Create repository" button to create the new repo.

You will then be redirected to the home page of the repo. The URL of the repo home page will follow the syntax outlined below:
https://github.com/<your_github_username>/github-actions-lab5

Open a new Terminal session, and make sure you are in your located your user’s home directory using the following command:

cd $HOME/Works

You should now be in the “/home/wasadmin/Works” directory.

Check you have a directory called “/home/wasadmin/Works” using the “pwd” command:

pwd

Result:

/home/wasadmin/Works

Clone the remote GitHub repo using the following command syntax, but replace “<your_github_username>” placeholder with your actual GitHub username:

git clone https://github.com/<your_github_username>/github-actions-lab5.git

You can see an example of the resulting output below:

Cloning into 'github-actions-lab5'...
warning: You appear to have cloned an empty repository.

Navigate into the repo root using the “cd” command as follows:

cd github-actions-lab5

Set the “global” git user.name, and user.name fields for all repos using the following commands:

git config --global user.name "Bob"
git config --global user.email bob@example.com

We will now copy existing template code into this repository, commit, and push the changes up to GitHub.

To copy the required template files in to the current directory by issuing the following command:

cp -R /home/wasadmin/Student_Templates/lab5/* .

Check that the files have been copied and are in the current folder by using the “tree” command:

tree

You should see the following files:

.
├── MyProject
│    ├── main.py
│    └── my_greeting_app
│    ├── __init__.py
│    └── greeter.py
├── main.initial.yaml
└── main.solution.yaml

2 directories, 5 files

Check the repo status using the following command:

git status

The result will be similar to the output in the following image:

Stage all new files, and commit them to GitHub by using the following command sequence:

git add .
git commit -m "Add initial files"
git push

The result will look similar to the following output below:

[main (root-commit) 3003bf2] Add initial files
 5 files changed, 75 insertions(+)
 create mode 100644 MyProject/main.py
 create mode 100644 MyProject/my_greeting_app/__init__.py
 create mode 100644 MyProject/my_greeting_app/greeter.py
 create mode 100644 main.initial.yaml
 create mode 100644 main.solution.yaml
Enumerating objects: 9, done.
Counting objects: 100% (9/9), done.
Delta compression using up to 4 threads
Compressing objects: 100% (8/8), done.
Writing objects: 100% (9/9), 1.23 KiB | 1.23 MiB/s, done.
Total 9 (delta 1), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (1/1), done.
To https://github.com/<your_github_username>/github-actions-lab5.git
 * [new branch]      main -> main

We are now ready to configure the repo for a GitHub Actions Workflow.

Using the same Terminal session we used above, ensure that you are in the “/home/wasadmin/Works/github-actions-lab5” directory (the repo root) using the following command:

cd /home/wasadmin/Works/github-actions-lab5

Create a new folder named "workflows" within a folder called “.github” using the following command:

mkdir -p .github/workflows

REMINDER: When we use the “-p” switch with the mkdir command, it means the entire multi-folder path is created.

Use the “tree” command to verify the correct structure exists:

tree .github

Result:

.github
└── workflows

1 directory, 0 files

We will now create a GitHub Actions workflow file, and view it in the console.

Copy the file called “main.initial.yaml” to create a new file called “main.yaml” into the new workflows folder you created. Use the following command:

cp main.initial.yaml .github/workflows/main.yaml

Display the contents of the file using the “cat” command:

cat .github/workflows/main.yaml

The result will be as follows:

name: Python App CI  # Name of the workflow

on:
  push:
    branches: [main]  # Trigger the workflow on push events to the main branch
  pull_request:
    branches: [main]  # Trigger the workflow on pull request events targeting the main branch

jobs:
  build:
    runs-on: ubuntu-latest  # Specify the operating system for the job to run on

    steps:
    - name: Checkout repository  # Checkout the repository code
      uses: actions/checkout@v2  # Use the actions/checkout action

    - name: Set up Python  # Set up the Python environment
      uses: actions/setup-python@v2  # Use the actions/setup-python action
      with:
        python-version: 3.x  # Specify the Python version as 3.x

    - name: Run the app  # Execute the simple python application (app.py)
      working-directory: MyProject
      env:
        PORT: 5005 #Example of how to set the port to 5005 via an environment variable
      # Executed the command "python main.py" (example of single command in runner shell)
      run: |
        python main.py

Open the YAML file (main.yaml) in Visual Studio Code (VSCode) using the VSCode command-line tool:

code .github/workflows/main.yaml

The result is “main.yaml” will be displayed in the VSCode editor as seen below:

Have a read through the file (main.yaml) noting that the file is in YAML format, which is recognized by VSCode. Currently, the YAML default of 2 spaces for indentation is being used.

However, in Python, the default convention is 4 spaces, while YAML maintains the default convention of 2 spaces.

It’s important to understand that you have the flexibility to choose any spacing you prefer in both Python and YAML, but it is crucial to maintain consistency throughout the entire file.

Close VSCode using File > Exit being sure to discard any changes you may have made to “main.yaml” while you were reading it.

In your Existing Terminal session, issue the following git commands to commit, and push the new workflow to GitHub:

git status
git add .
git commit -m "Add workflow file"
git push

We will now move on to check the status of the Workflow in the GitHub Actions interface.

To monitor your workflow execution, navigate to the “Actions” tab in your GitHub repository, as shown in the image below:

As we can see in the image above, all the runs from each workflow in your repository will be displayed here.

If you only see “red” run entries, it means there might be a mistake in your YAML file. Please ensure that it matches the example provided.

If the YAML syntax is correct, a “green” checkmark will appear next to the most recent event (or workflow run event) entry, which indicates a successful execution of the workflow.

Wait for the job titled “Add workflow file” to complete successfully.

We can now move on, and update the workflow (main.yaml) to trigger another run.

In a New or the Existing terminal session (if you have not closed the previous terminal session) check you are in the “/home/wasadmin/Works/github-actions-lab5” directory:

cd /home/wasadmin/Works/github-actions-lab5

Open the “main.yaml” using the VSCode command-line shortcut:

code .github/workflows/main.yaml

Modify the existing YAML code to append a newline after the line that contains “python main.py” (around line 28), then append a new step (around line 30), using the following YAML.

- name: Status
  run: echo "Job Completed"

Make sure the indentation is correct as shown in the image below:

Save the changes using VSCode menu: File > Save, and exit VSCode using File > Exit

Commit, and push the changes to GitHub

git status
git add .
git commit -m "Updated workflow file"
git push

Check out the updated workflow in GitHub Actions as we did before, and see that there will be a new run logged.

As seen in the image above, there is a new workflow-run logged titled with the commit message of the last commit.

Wait for the workflow to complete.

Click on the Workflow run titled “Updated workflow file”, or the latest one if you have made other commit using a different message:

You will then be taken to the details page of the run you have just clicked on.

Locate the “main.yaml” “on:push” event, and click on the “build” job as seen below:

The build output will be displayed result will be similar to the following image:

Expand the “build” job’s step labeled “Status” to see the output message we added to the Workflow:

The result will be as follows:

On your lab machine, close all instances of VSCode Windows, any Browser Windows, and any remaining open Terminal sessions, ready for the next lab.

Log into your personal GitHub account which you are using for this lab.

Navigate to the main "Dashboard” (https://github.com/dashboard) of your GitHub account. You do this by clicking on the Dashboard link in the main top navigation toolbar as seen below:

or, by using the left-hand-side hamburger menu as seen below, and selecting “Home”.

Either use the global quick toolbar "+" "button, or from the left-hand-side menu choose the "New" button, or if shown “Create a new repository” button, as seen in the image below.

In the "Create a new repository" page (https://github.com/new) type “github-actions-lab6” for the Repository name:

github-actions-lab6

Optionally add a description such as

Lab 6 GitHub Actions

Choose “Private” repo.

Click "Create repository" button to create the new repo.

You will then be redirected to the home page of the repo. The URL of the repo home page will follow the syntax outlined below:
https://github.com/<your_github_username>/github-actions-lab6

Open a new Terminal session, and make sure you are in your located your user’s home directory using the following command:

cd $HOME/Works

You should now be in the “/home/wasadmin/Works” directory.

Check you have a directory called “/home/wasadmin/Works” using the “pwd” command:

pwd

Result:

/home/wasadmin/Works

Clone the remote GitHub repo using the following command syntax, but replace “<your_github_username>” placeholder with your actual GitHub username:

git clone https://github.com/<your_github_username>/github-actions-lab6.git

You can see an example of the resulting output below:

Cloning into 'github-actions-lab6'...
warning: You appear to have cloned an empty repository.

Navigate into the repo root using the “cd” command as follows:

cd github-actions-lab6

Verify the global git user.name, and user.name fields are set for all repos using the following commands:

git config --global --list

The Result will be similar to the following output:

credential.helper=store
user.name=Bob
user.email=bob@example.com

If the user.name, and user.email fields are not set, then issue the following commands:

git config --global user.name "Bob"
git config --global user.email bob@example.com

We will now copy existing template code into this repository, commit, and push the changes up to GitHub.

To copy the required template files in to the current directory by issuing the following command:

cp -R /home/wasadmin/Student_Templates/lab6/* .

Check that the files have been copied and are in the current folder by using the “tree” command as shown below:

tree

You should see the following files:

.
├── MyProject
│   ├── my_app
│   │   ├── __init__.py
│   │   ├── app.py
│   │   └── message.py
│   ├── requirements.txt
│   └── tests
│   ├── __init__.py
│   └── test_app.py
└── pipeline.initial.yaml

3 directories, 7 files

Check the repo status using the following command:

git status

Result:

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	MyProject/
	pipeline.initial.yaml
nothing added to commit but untracked files present (use "git add" to track)

Stage all new files, and commit them to GitHub by using the following command sequence:

git add .
git commit -m "Add initial files"
git push

The result will look similar to the following output below:

Using the Existing Terminal session we used earlier, ensure that you are in the “/home/wasadmin/Works/github-actions-lab6” directory (the repo root) using the following command:

cd /home/wasadmin/Works/github-actions-lab6

Create a new folder named "workflows" within a folder called “.github” using the following command:

mkdir -p .github/workflows

REMINDER: When we use the “-p” switch with the mkdir command, it means the entire multi-folder path is created.

Use the “tree” command to verify the correct structure exists:

tree .github

Result:

.github
└── workflows

1 directory, 0 files

We will now create a GitHub Actions workflow file named “pipeline.yaml” , and view it in the console.

Copy the template file called “pipeline.initial.yaml” to create a new file called “pipeline.yaml” into the new workflows folder you created. Use the following command:

cp pipeline.initial.yaml .github/workflows/pipeline.yaml

Display the contents of the file using the cat command:

cat .github/workflows/pipeline.yaml

The result will be as follows:

name: Python CI Pipeline

on:
  push:
    branches:
      - main
  pull_request:
    branches:
      - main

jobs:
  build:
    name: Build
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: 3.x

      - name: Install dependencies
        working-directory: MyProject
        run: |
          python -m pip install --upgrade pip

Now open the YAML file (pipeline.yaml) in Visual Studio Code (VSCode) using the VSCode command-line tool:

code .github/workflows/pipeline.yaml

The result is “pipeline.yaml” will be displayed in the VSCode editor as seen below:

Have a read through the file (pipeline.yaml) noting that the file is in YAML format, which is recognized by VSCode. Currently, the YAML default of 2 spaces for indentation is being used.

However, in Python, the default convention is 4 spaces, while YAML maintains the default convention of 2 spaces.

It’s important to understand that you have the flexibility to choose any spacing you prefer in both Python and YAML, but it is crucial to maintain consistency throughout the entire file.

Demystifying the pipeline file (pipeline.yaml)

This simple pipeline (pipeline.yaml) is activated on push and pull requests to the main branch, executing the following tasks:

Close VSCode, using File > Exit, being sure to discard any changes you may have made to “pipeline.yaml” while you were reading it.

Issue the following git commands to commit, and push the new workflow to GitHub:

git status
git add .
git commit -m "Add pipeline file"
git push

We will now move on to check the status of the Workflow in the GitHub Actions interface.

To monitor your workflow execution, navigate to the “Actions” tab in your GitHub repository, as shown in the image below:

If you catch the update in time, you might see the following image, which shows the workflow in progress:

If you only see “red” run entries, it means there might be a mistake in your YAML file. Please ensure that it matches the example provided.

If the YAML syntax is correct, a “green” checkmark will appear next to the most recent event (or workflow run event) entry, which indicates a successful execution of the workflow.

We can now move on, and update the pipeline workflow (pipeline.yaml) to trigger another run.

Before continuing, ensure that there has been a successful run. The workflow run will be titled “”Add pipeline file”, and it will have a “green” checkmark indicating success.

Using the Existing Terminal session, issue the following command to open the “requirements.txt” file into VSCode:

code MyProject/requirements.txt

The open “requirements.txt” file will contain only the “Flask” dependency

Add the new dependency entry to the file by appending the following text on a newline, after the “Flask” entry:

pytest==7.3.2

The updated “requirements.txt” file should now contain both the “Flask”, and “pytest==7.3.2” dependencies.

Save the requirements.txt file using File > Save, and Exit VSCode using File > Exit

In a New or Existing Terminal session (if you have not closed the previous Terminal session) ensure you are in the “/home/wasadmin/Works/github-actions-lab6” directory, by running the following command:

cd /home/wasadmin/Works/github-actions-lab6

Open the “pipeline.yaml” using the VSCode command-line shortcut:

code .github/workflows/pipeline.yaml

Now, modify the existing YAML code to add a newline, then append a new step after the newline (should be around line 31), using the following YAML.

- name: Run unit tests using pytest
  working-directory: MyProject
  id: unit-tests
  run: pytest

Double check your edits to make sure the indentation is correct as shown in the image below:

Save the changes using File > Save, and exit VSCode using File > Exit

In your Existing Terminal session, commit, and push the changes to GitHub:

git status
git add .
git commit -m "Updated pipeline to include unit test"
git push

Check out the updated workflow in the GitHub Actions interface as we did before, and see that there will be a newly logged run.

The result will be similar to the following image below:

As seen in the image above, there is a new workflow run logged titled with the commit message of the last commit.

Before continuing, ensure that there has been a successful run.

Click on the Workflow run titled “Updated pipeline to include unit test”, or the latest one if you have made other commit:

You will then be taken to the details page of the run you have just clicked on.

Locate the “pipeline.yaml” “on:push” event, and click on the “build” job as seen above.

The build (job) output will be displayed, and the result will be similar to the following image below:

Expand the “Build” job’s step labeled “Run unit tests using pytest” to see the result of the test step which we added to the pipeline:

The result will be as follows:

Open a New or Existing Terminal session.

Confirm you are in the “/home/wasadmin/Works/github-actions-lab6” directory

cd /home/wasadmin/Works/github-actions-lab6

Open “pipeline.yaml” in VSCode using the command-line shortcut

code .github/workflows/pipeline.yaml

Append a new entry to the “Run unit tests using pytest” step using the following YAML snippet:

continue-on-error: true

The updated job, will be as follows:

Next, continue to edit “pipeline.yaml” appending a new line to nicely separate the existing jobs (around line 36).

Then (around line 37) append a new Job named “Deploy to Test Environment” by copying and pasting this YAML below:

deploy:
    name: Deploy to Test Environment
    needs: build
    if: ${{ needs.build.result == 'success' }}
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Set up Python
        uses: actions/setup-python@v2
        with:
          python-version: 3.x

      - name: Deploy to test environment
        run: |
          # Add your deployment steps here
          echo "Deploying to test environment..."

The resulting updated “pipeline.yaml” will look exactly like the following image:

Validate that your “pipeline.yaml” file is exactly the same, and the indentations are aligned. Then Save the “pipeline.yaml” file using File > Save, and exit VSCode using File > Exit.

In your Terminal session, Stage, Commit, and Push the changes to GitHub using the following commands:

git status
git add .
git commit -m "Added deploy job"
git push

Go to GitHub Actions tab (as we have done before) and review the status of the latest commit.

If you get to the GitHub Actions page in time, you might see the queued job as seen in the example below:

Wait for the job to complete.

Click on the job row labeled “Added deploy job” to see the jobs and their individual status as they complete in accordance with the declared workflow.

Looking at this image below, we can see that once we drill down into the pipeline that each job is separated out as seen below:

Each stage (job) of the pipeline works through the steps assigned to that job as defined in the workflow the YAML (in our lab, this is pipeline.yaml).

Once the entire workflow is complete aka our pipeline, we will see that each stage (job) has it’s own green tock indicating that the job is complete.

Click on the “Deploy to Test Environment” job, to drill down in to the details as indicated below:

Expand the step labeled “Deploy to test environment” to see the sample placeholder message that is indicating that the deployment is being made to the test environment.

Obviously, this deployment stage (job) is just a placeholder to demonstrate a fictitious deployment to an environment only if the unit tests complete and are successful.

Congratulations! You have successfully created a multi-job GitHub Actions pipeline to build, test, and deploy your Python project.

Close all open Terminal sessions.

Close all open Web Browser windows.

Close all open VSCode files & windows.

Open a new terminal session.

Create a new directory for your project using the following command:

mkdir -p /home/wasadmin/Works/lab7/MyProject

Navigate to the newly created directory “/home/wasadmin/Works/lab7/MyProject”:

cd /home/wasadmin/Works/lab7/MyProject

Confirm you are in the “/home/wasadmin/Works/lab7/MyProject” directory using the Print Working Directory (pwd) command:

pwd

Result:

/home/wasadmin/Works/lab7/MyProject

Launch VSCode using the current directory for context, by using the VSCode command-line shortcut as follows:

code .

If you are prompted with an “Authentication required” pop-up window, use “wasadmin” as the password.

VSCode will launch, and open the folder and set the working context to be the “/home/wasadmin/Works/lab7/MyProject” as seen in the image below:

Create a new file called “app.py” in the project root using the VSCode many File > New or click on the “New File” icon as shown in the two images below:

Copy and Past the following Python code into “app.py”:

from flask import Flask, jsonify

app = Flask(__name__)

@app.route('/hello-message')
def hello_message():
    message = {'message': 'Hello!'}
    return jsonify(message)

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=8080)

This code creates a basic Flask application with a single route “/hello-message” that returns a JSON response with a greeting message.

Verify that the code looks exactly the same as the image below, making sure that all the indentation is correct as seen below

Save the new “app.py” using the VSCode main menu option File > Save, but do not close/exit the VSCode window, keep it open.

Open a new VSCode Integrated Terminal session, by using the menu option Terminal > New Terminal, as shown in the image below:

The Python extension has been installed already for VSCode, so your terminal session, might load a previous “pyenv” that has been configured from another lab.

If this happens, then you can use the VSCode Preference > Settings menu, and locate the setting “Python > Terminal: Activate in Current Terminal” and set it to false. The json fo r this setting is "python.terminal.activateEnvironment": false

You can also search for this setting by typing “python.terminal.activateEnvironment” in the setting search bar.

Productivity Tip: Once you have opened a new terminal in VSCode, you can maximize the VSCode window and adjust the windows within the interface as needed to maximize your available screen space. This will provide you with a larger working area and allow you to focus on your code and terminal output more efficiently.

In the new VSCode terminal pane located underneath the code, type the tree command to confirm that “app.py” exists as follows:

tree

The result will be as shown in the image below:

To run the Flask application, we will need to install the flask dependency.

Run the Python Installer manually using the “pip” command as follows:

pip install Flask

The result is the latest Flask dependency is now installed as seen below. Message may vary on time and version.

To run the Flask application, issue the following command to the python interpreter.

python app.py +

The Flask Development Server based upon version installed will start on the app, and listen on port 8080. The output will look similar to the following screen:

Open a new browser session using the “Chrome” icon either in the main Ubuntu “Desktop Launcher” or using the main Ubuntu “Applications” menu. Be aware, you might have the VSCode window maximized, so to see the Desktop Launcher you can restore the VSCode window to see the “Desktop Launcher”.

Navigate to the running Flask Application’s default-page in the open browser window using the following URL:
http://localhost:8080/hello-message

The result will be the “Javascript Object Notation Format (JSON)” formatted-output of the route “/hello-message” as seen below:

In the next part, we will expand the applications code-base to add additional more path-based routes.

Stop the Flask Application, by using the key combination CTRL-C in the VSCode terminal session, then close the Integrate Terminal session to give yourself more screen space before you edit the code as seen below:

Edit “app.py” file in VSCode, add a newline after line 8 and append the following code, by copying and pasting the code below after the new line (this should be around line 10).

@app.route('/goodbye-message')
def goodbye_message():
    message = {'message': 'Goodbye!'}
    return jsonify(message)

@app.route('/custom-message/<name>')
def custom_message(name):
    message = {'message': f'Hello, {name}!'}
    return jsonify(message)

The result will look exactly as below:

Verify the code is the same as above, and the indentations are correct, then Save the file using File > Save.

Either use the existing VSCode terminal session, or open a new VSCode Integrated Terminal Session, using Terminal > New Terminal in the main VSCode menu.

Inside the terminal session, type the following command to start the Flask Application again as we did earlier.

python app.py

With the updated code, and the Flask Application (app.py) running again, let’s test the new routes.

Either use an existing Chrome browser session, or open a new Chrome browser session as we did previous in the lab, then navigate to the following URL’s one by one.
http://localhost:8080/hello-message

Returns the JSON response with "Hello!" message as seen below:

http://localhost:8080/goodbye-message

Returns the JSON response with "Goodbye!" message as seen below:

http://localhost:8080/custom-message/<yourname>;

Here is an example using the string “Bob” as the parameter:
http://localhost:8080/custom-message/Bob

The result is as per the image below:

You have now successfully seen a Flask application produce multiple endpoints using simple path-based routing.

Using VSCode, edit app.py, add a new line after the previous routes (should be about line 19), and append the following code snippets by copying and pasting on line 20:

@app.route('/api/v1/users')
def get_users():
    users = [
        {'id': 1, 'name': 'John'},
        {'id': 2, 'name': 'Jane'},
        {'id': 3, 'name': 'Alice'}
    ]
    return jsonify(users)

@app.route('/api/v1/posts')
def get_posts():
    posts = [
        {'id': 1, 'title': 'First Post'},
        {'id': 2, 'title': 'Second Post'},
        {'id': 3, 'title': 'Third Post'}
    ]
    return jsonify(posts)

Verify the code looks exactly as seen below:

In VSCode, save “app.py” using File > Save in the VSCode menu:

Before we run the code, lets quickly discuss the code we have just added.

In this updated code, we have introduced two new subfolder path routes: “/api/v1/users” and /api/v1/posts. These routes are nested within the “/api/v1” path, creating a logical grouping for related functionalities.

The “/api/v1/users” route returns a JSON response with a list of users, while the “/api/v1/posts” route returns a JSON response with a list of posts.

You can access these subfolder path routes by appending the corresponding paths to the base URL of your Flask application. For example:

To retrieve the list of users: http://localhost:8080/api/v1/users

To retrieve the list of posts: http://localhost:8080/api/v1/posts

By organizing your API endpoints into subfolder path routes, you can achieve a more structured and intuitive API design. This allows for better separation of concerns and scalability as your microservice grows.

As before, close the currently running Flask app using CTRL-C in the Terminal and re-launch the updated Flask application using the following command:

python app.py

Either use an Existing Chrome browser session that is already open, or Open a new Chrome browser session.

Open the following URLs one by one in your existing Chrome Browser window to verify the code is working as intended:

To retrieve the list of users, use the following URL:
http://localhost:8080/api/v1/users

The JSON response will be as follows:

To retrieve the list of posts (blog entries), use the following URL:
http://localhost:8080/api/v1/posts

The JSON response will be as follows:

Congratulations, the Lab is complete.

Stop the Flask Application using CTRL-C in the VSCode Integrated Terminal where the app is running.

Close all Terminal sessions.

Close VSCode, using File > Exit.

Close all open Web Browser windows.

Open a new terminal session using the “Ubuntu Desktop Launcher” or Ubuntu “Applications” menu.

Create a new working folder called “/home/wasadmin/Works/lab8” and navigate to the folder by issuing the following commands:

mkdir -p /home/wasadmin/Works/lab8
cd /home/wasadmin/Works/lab8

Confirm you are in the “/home/wasadmin/Works/lab8” directory by using the “pwd” command as follows:

pwd

Result:

/home/wasadmin/Works/lab8

Execute the following commands to create a new directory for your project and set up a virtual environment by issuing the 4 commands below:

mkdir book-service
cd book-service
python3 -m venv .venv
source .venv/bin/activate

The result will be a new directory called book-service, and an activated virtual environment named “.venv” as seen below:

What did we just do?

“mkdir book-service”:

This command creates a new directory named "book-service" in the current working directory. The directory will be used to organize your project files.

“cd book-service”:

This command changes the current working directory to "book-service". It allows you to navigate into the newly created directory.

“python3 -m venv .venv”:

This command creates a new virtual environment named ".venv" within the "book-service" directory. A virtual environment is an isolated Python environment that allows you to install packages and dependencies specific to your project without interfering with your system-wide Python installation.

“python3” invokes the Python 3 interpreter.

“-m venv” is a module in Python’s standard library used to create virtual environments.

“.venv” is the name of the virtual environment. You can choose any name you like, but ".venv" is a common convention, and since it begins with a period “.” it is often excluded from being committed to git repos when using typical .gitignore files.

“source .venv/bin/activate”:

This command activates the virtual environment. When the virtual environment is activated, any subsequent Python-related commands will use the packages and dependencies installed within the virtual environment instead of the global system-wide Python environment.

“source” is a command used to execute the script provided as an argument within the current shell environment.

“.venv/bin/activate” is the script that activates the virtual environment by modifying the PATH and other environment variables.

After running these commands, you will have a new directory "book-service" with a virtual environment set up inside it.

You can install dependencies and run your Flask application within the virtual environment, isolating this app from other Python projects.

Now, lets get back to the tasks at hand.

In the book-service directory, create a new file named requirements.txt using the touch command, which will create a new empty file.

touch requirements.txt

Open the “requirements.txt” file in VSCode using the command-line short-cut:

code requirements.txt

Using VSCode, edit the “requirements.txt” file by adding the following line:

Flask

Save the “requirements.txt” file, using File > Save, and Exit VSCode using File > Exit.

Install the dependencies using pip:

pip install -r requirements.txt

To create the “app.py” file, we will copy an existing template file called “app_initial.py” from the “/home/wasadmin/Student_Templates/lab8” directory using the following command:

cp /home/wasadmin/Student_Templates/lab8/app_initial.py app.py

Verify the current structure of the “book-service” folder, to ensure the “app.py” file exists using the tree command:

tree

The result should resemble the output below:

.
├── app.py
└── requirements.txt

0 directories, 2 files

Open the “app.py” file in VSCode using the following command-line shortcut:

code app.py

Once the “app.py” file is opened in VSCode, have a read through the file.

Explanation of “app.py”

The code sets up a Flask application with routes for different REST verb.

The “books” list represents an in-memory collection of books (in a real application, you would use a database instead).

Locate the routes and their corresponding functions as follows:

@app.route('/books', methods=['GET'])

Returns the list of all books as a JSON response.

@app.route('/books', methods=['POST'])

Adds a new book to the collection based on the data provided in the request body and returns the created book as a JSON response.

@app.route('/books/<int:book_id>', methods=['GET'])

Returns the details of a specific book based on its ID as a JSON response.

@app.route('/books/<int:book_id>', methods=['PUT'])

Updates the details of a specific book based on its ID using the data provided in the request body and returns the updated book as a JSON response.

@app.route('/books/<int:book_id>', methods=['DELETE'])

Deletes a specific book based on its ID and returns a JSON response indicating success.

It is not required that you understand the code complete, just appreciate that it will provide endpoints that response to the implemented REST Verbs (GET, POST, PUT, DELETE).

Close the “app.py” file using the VSCode menu option: File > Exit.

Using the exact same terminal which was used to launch “app.py into VSCode, ensure you are still in the correct directory “/home/wasadmin/Works/lab8/book-service” buy using he pwd command:

pwd

Result:

/home/wasadmin/Works/lab8/book-service

Copy the template “/home/wasadmin/Student_Templates/lab8/books_initial.json books.json” file to create a pre-populated file called books.json using the following command:

cp /home/wasadmin/Student_Templates/lab8/books_initial.json books.json

Ensure that “books.json” has been copied, and contains the sample data as follows:

cat books.json

The, resulting JSON output will be as follows:

[
    {
        "id": 1,
        "title": "The Great Gatsby",
        "author": "F. Scott Fitzgerald",
        "genre": "Fiction"
    },
    {
        "id": 2,
        "title": "To Kill a Mockingbird",
        "author": "Harper Lee",
        "genre": "Fiction"
    },
    {
        "id": 3,
        "title": "1984",
        "author": "George Orwell",
        "genre": "Fiction"
    }
]

Explanation of “app.py” and it’s use of “books.json”

The “books.json” file is used to store the data of the books in JSON format. It serves as a persistent storage for the book collection managed by the Flask application (app.py), below is a brief overview of it’s use:

Start the application by issuing the following command in your existing open terminal session:

python app.py

In these example, we are using a command-line approach utilizing the “curl” command.

To retrieve the list of all books, we can send a GET request to: “http://localhost:5000/books”.

The next few steps, will guide us how to do this.

Leaving the application running, launch another New (separate) Terminal session using the open-terminal’s menu system-option File > New Window as shown below:

In the new terminal session window use the “curl” command to test the GET request as follows:

curl -X GET http://localhost:5000/books/1

The result, will be a call to the applications endpoint using a GET request, and return the following output of the book item that has an “id” field equal to 1:

{"author":"F. Scott Fitzgerald","genre":"Fiction","id":1,"title":"The Great Gatsby"}

To add a new book with using the “curl” command, execute the following command:

curl -X POST -H "Content-Type: application/json" -d '{"title": "The Catcher in the Rye", "author": "J.D. Salinger", "genre": "Fiction"}' http://localhost:5000/books

The result below, will be the following response from the endpoint:

{"author":"J.D. Salinger","genre":"Fiction","id":4,"title":"The Catcher in the Rye"}

Explanation of what just happened:

The command above, sends a POST request to the “http://localhost:5000/books” endpoint with the JSON data representing the new book in the request body.

The “-X POST” flag specifies the HTTP verb as POST, and the '-H "Content-Type: application/json' flag sets the request header to indicate that the content is in JSON format.

The “-d” flag followed by the JSON data enclosed in single quotes represents the request body.

The JSON data sent in the request body corresponds to the book details:

{
    "title": "The Catcher in the Rye",
    "author": "J.D. Salinger",
    "genre": "Fiction"
}

Executing the “curl” command will add a new book with the specified details and an Id of 4 to the book collection. The reason the Id number equals 4, is because in the “app.py” code, the add_book() function calculates how may existing book items exist currently in “books.json”, and increments the count by 1.

Issue the following “curl” command to get the latest list of books:

curl -X GET http://localhost:5000/books

Resulting json response is as follows:

[{"author":"F. Scott Fitzgerald","genre":"Fiction","id":1,"title":"The Great Gatsby"},{"author":"Harper Lee","genre":"Fiction","id":2,"title":"To Kill a Mockingbird"},{"author":"George Orwell","genre":"Fiction","id":3,"title":"1984"},{"author":"J.D. Salinger","genre":"Fiction","id":4,"title":"The Catcher in the Rye"}]

Update the book with ID 1 by issuing the following “curl” command:

curl -X PUT -H "Content-Type: application/json" -d '{"title": "New Title", "author": "New Author", "genre": "New Genre"}' http://localhost:5000/books/1

The resulting output from the response of the request wil be as follows:

{"author":"New Author","genre":"New Genre","id":1,"title":"New Title"}

What just happened?

The command used above, sends a PUT request to the “http://localhost:5000/books/1`”endpoint with the specified JSON body containing the updated book details.

The response will include the updated details of the book in JSON format if it exists.

To list the book with ID 1, issue the following curl command:

curl -X GET http://localhost:5000/books/1

The result will be this response:

{"author":"New Author","genre":"New Genre","id":1,"title":"New Title"}

We can can see that the book item with id=1 has been updated.

We will now look to delete this record from the list.

In the same terminal we have been using to issue previous curl commands, delete the book with ID 1, by issuing the following curl command:

curl -X DELETE http://localhost:5000/books/1

The resulting response message displayed will as follows:

{"message":"Book deleted"}

Check the result using the following Get command:

curl -X GET http://localhost:5000/books

The resulting output showing that the book with id=1 has been removed from the book list as seen below:

[{"author":"Harper Lee","genre":"Fiction","id":2,"title":"To Kill a Mockingbird"},{"author":"George Orwell","genre":"Fiction","id":3,"title":"1984"},{"author":"J.D. Salinger","genre":"Fiction","id":4,"title":"The Catcher in the Rye"}]

This concludes this lab.

Stop the running Flask Application using CTRL-C in the terminal where the Flask App (app.py) is running.

Close all open Terminal sessions.

Close all open Web Browser windows.

Close all open VSCode files & windows.

Log into your personal GitHub account which you are using for this lab.

Navigate to the main "Dashboard” (https://github.com/dashboard) of your GitHub account. You do this by clicking on the Dashboard link in the main top navigation toolbar as seen below:

or, by using the left-hand-side hamburger menu as seen below, and selecting “Home”.

Either use the global quick toolbar "+" "button, or from the left-hand-side menu choose the "New" button, or if shown “Create a new repository” button, as seen in the image below.

In the "Create a new repository" page (https://github.com/new) enter the following name for the Repository.

github-actions-lab9

Add a description as follows:

Lab 9 GitHub Actions

Choose “Private” repo.

Click "Create repository" button to create the new repo.

You will then be redirected to the home page of the repo. The URL of the repo home page will follow the syntax outline

Open a new Terminal session, and make sure you are in your located your user’s home directory using the following command:

cd $HOME/Works

You should now be in the “/home/wasadmin/Works” directory.

Check you have a directory called “/home/wasadmin/Works” using the “pwd” command:

pwd

Result:

/home/wasadmin/Works

Clone the remote GitHub repo using the following command syntax, but replace “<your_github_username>” placeholder with your actual GitHub username:

git clone https://github.com/<your_github_username>/github-actions-lab9.git

Navigate into the cloned-repo root using the “cd” command as follows:

cd github-actions-lab9

We will now copy existing template-code into this repository, commit, and push the changes up to GitHub.

To copy the required template files in to the current directory by issuing the following command:

cp -R /home/wasadmin/Student_Templates/lab9/* .

Check that the files have been copied and are in the current folder by using the “tree” command as shown below:

tree

You should see the following files:

├── MyProject
│   ├── Dockerfile
│   ├── build_and_push.sh
│   ├── build_local_image.sh
│   ├── config.conf
│   ├── create_env.sh
│   ├── data_scripts
│   │   ├── delete_all_customers.sh
│   │   ├── delete_all_orders.sh
│   │   ├── delete_all_products.sh
│   │   ├── delete_customer_1.sh
│   │   ├── delete_customer_by_id.sh
│   │   ├── delete_order_1.sh
│   │   ├── delete_order_by_id.sh
│   │   ├── delete_product_1.sh
│   │   ├── delete_product_by_id.sh
│   │   ├── get_customers.sh
│   │   ├── get_orders.sh
│   │   ├── get_products.sh
│   │   ├── insert_sample_customer_data.sh
│   │   ├── insert_sample_order_data.sh
│   │   ├── insert_sample_product_data.sh
│   │   ├── sample_customer_data.json
│   │   ├── sample_order_data.json
│   │   └── sample_product_data.json
│   ├── install_local.sh
│   ├── my_app
│   │   ├── __init__.py
│   │   ├── app.py
│   │   ├── templates
│   │   │   └── index.html
│   │   └── tests
│   │   ├── __init__.py
│   │   ├── test_app.py
│   │   └── test_local.sh
│   ├── requirements.txt
│   ├── run_app.sh
│   ├── run_container.sh
│   └── run_container_local.sh
├── pipeline.final.yaml
└── pipeline.initial.yaml

5 directories, 36 files

Check the repo status using the following command:

git status

Result:

On branch main

No commits yet

Untracked files:
  (use "git add <file>..." to include in what will be committed)
	MyProject/
	pipeline.final.yaml
	pipeline.initial.yaml

nothing added to commit but untracked files present (use "git add" to track)

Stage all new files, and commit them to GitHub by using the following command sequence:

git add .
git commit -am "Add initial files"
git push

We are now almost ready to configure the repo for a GitHub Actions Workflow. Before we do so, we need to define some secrets. These secrets will store details of the DockerHub account we will be creating for the deployment stage of our GitHub Actions pipeline workflow.

Open a new browser window using the Chrome icon desktop Launcher:

Go to the Docker Hub website (https://hub.docker.com/), if you do not have an existing personal Docker Hub account, then register a new account. Once you have an existing verified Docker Hub account, sign-in to your account account.

Once logged into Docker Hub, click on your profile icon in the top-right corner and select "Account Settings" from the drop-down menu as seen below:

In the Account Settings page, navigate to the "Security" tab.

Locate the "Access Tokens" section and click on the "New Access Token" button.

Enter a name for your access token in the "Access Token Description" field. This name is for your reference and should be descriptive to identify the purpose of the token. It is a good idea to use something like “wa2917 lab9” as seen below:

Once you have entered an “Access Token Description”, and set the desired “Access Permissions”, click on the "Generate" button.

Copy the token using the copy-icon as seen in the image below:

We will now store the token value since it will not be shown again for security reasons.

Open a new terminal using Applications > Terminal option or click on the Terminal icon in the main desktop launcher.

Create a new/open existing “my_tokens.txt” file in VSCode by entering the following command.

code ~/Desktop/my_tokens.txt

Add a description similar to the image above, then Paste your Docker Hub token into the file.

Save the file using the File > Save menu option, then use File > Exit to close VSCode.

The result will be a file called “my_tokens.txt” on the Ubuntu Desktop as seen below:

We are now ready to use the new DockerHub Personal Access Token (PAT) as a secret in in GitHub.

In an Existing or New Chrome Browser session, navigate to your “github-actions-lab9” repository home-page:
https://github.com/<your-username>/github-actions-lab9

Click on the "Settings" tab for the repo.

In the left sidebar, click on "Security/Secrets and Variables".

Select the sub-men “Actions”.

Click on the "New repository secret" button.

Enter the name “DOCKERHUB_USERNAME” and use your Docker Hub username as the Secret value as seen below:

Double check and make sure to use the correct dockerhub username.

Click “Add secret” button

You will see the first secret “DOCKERHUB_USERNAME” has been added, as seen below:

Now we will follow the same process to create the “DOCKERHUB_TOKEN” secret.

Click the “new repository secret” button.

Type the Name “DOCKERHUB_TOKEN” and copy/paste the recently generated Docker Hub access token as the Secret’s value as shown below:

Click “Add secret” button

You will see the first secret “DOCKERHUB_TOKEN” has been added, as seen below:

Make sure you have followed the above steps to add two secrets.

Now that we have the secrets are added, we can access them in GitHub Actions workflow using the syntax ${{ secrets.SECRET_NAME }}, where SECRET_NAME is the name of the secret you set up.

To reference the Docker Hub username secret, you would use a variable in the workflow YAML for example: ${{ secrets.DOCKERHUB_USERNAME }}.

We will now create the workflow and add the two secrets.

Using the Existing Terminal session we used earlier in the lab, ensure that you are in the “/home/wasadmin/Works/github-actions-lab9” directory (the repo root) using the following command:

cd /home/wasadmin/Works/github-actions-lab9

Create a new folder named "workflows" within a folder called “.github” using the following command:

mkdir -p .github/workflows

REMEMBER: When we use the “-p” switch with the mkdir command, it means the entire multi-folder path is created.

Use the “tree” command to verify the correct structure exists:

tree .github

Result:

.github
└── workflows

1 directory, 0 files

We will now create a GitHub Actions workflow file named “pipeline.yaml”, and view it in the console.

Copy the template file called “pipeline.initial.yaml” to create a new file called “pipeline.yaml” into the new workflows folder you created. Use the following command:

cp ./pipeline.initial.yaml .github/workflows/pipeline.yaml

Display the contents of the file using the “cat” command:

cat .github/workflows/pipeline.yaml

The result will be as follows:

name: Build, Test, and Push Docker Image

on:
  push:
    branches:
      - main  # Change this to your main branch name

jobs:
  build-test-push:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Set up Docker Buildx
        uses: docker/setup-buildx-action@v1

      - name: Login to DockerHub
        uses: docker/login-action@v2
        with:
          username: ${{ secrets.DOCKERHUB_USERNAME }}
          password: ${{ secrets.DOCKERHUB_TOKEN }}

      - name: Build and push
        uses: docker/build-push-action@v2
        with:
          context: MyProject
          push: true
          tags: ${{ secrets.DOCKERHUB_USERNAME }}/my_app:latest

Now open the YAML file (pipeline.yaml) in Visual Studio Code (VSCode) using the VSCode command-line tool:

code .github/workflows/pipeline.yaml

The result is “pipeline.yaml” will be displayed in the VSCode editor as seen below:

Have a read through the file noting the file is in YAML format which is recognized by VSCode. Currently, the YAML default of 2 spaces for indentation is being used.

However, in Python, the default convention is 4 spaces, while YAML maintains the default convention of 2 spaces.

It’s important to understand that you have the flexibility to choose any spacing you prefer in both Python and YAML, but it is crucial to maintain consistency throughout the entire file.

Close VSCode, using File > Exit, being sure to discard any changes you may have made to “pipeline.yaml” while you were reading it.

In the Existing Terminal session, issue the following git commands to commit and push the new workflow to GitHub:

git status
git add .
git commit -m "Add pipeline file"
git push

We will now move on to check the status of the Workflow in the GitHub Actions interface.

To monitor your workflow execution, navigate to the “Actions” tab in your GitHub repository, as shown in the image below:

As we can see in the image above, all runs from each workflow in your repository will be displayed.

If you only see “red” run entries, it means there might be a mistake in your YAML file. Please ensure that it matches the example provided.

If the YAML syntax is correct, a “green” checkmark will appear next to the most recent event (or workflow run event) entry, which indicates a successful execution of the workflow.

We can now move on to update the pipeline workflow (pipeline.yaml) with the required additional YAML to add another job (stage) to test the docker image and trigger another run.

Ensure that the “Add pipeline” job is successful before continuing.

In a New or existing Terminal session (if you have not closed the previous Terminal session) ensure you are in the “/home/wasadmin/Works/github-actions-lab9” directory, by running the following command:

cd /home/wasadmin/Works/github-actions-lab9

Copy the template file called “pipeline.final.yaml” to replace the existing “pipeline.yaml” into the “.github/workflows folder”, using the following command:

cp ./pipeline.final.yaml .github/workflows/pipeline.yaml

Open the “pipeline.yaml” file in VSCode using the following command:

code .github/workflows/pipeline.yaml

Reading through the “pipeline.yaml” we will see the additional job labelled as “test” as seen in the image below:

One you have read through the code, exit VSCode using File > Exit

Commit, and push updated “pipeline.yaml” file to GitHub

git status
git add .
git commit -m "Added test job"
git push

Check out the updated workflow in the GitHub Actions interface as we did before to see a new logged run.

The result will be similar to the following image below:

As seen in the image above, there is a new workflow run logged titled with the commit message of the last commit.

Once the Workflow run is complete, click on the Workflow run titled
“Added test job”, or the latest one if you have made other commit:

You will then be taken to the details page of the run you have just clicked on, which will show the separate outputs for each job in the pipeline.

Locate the “pipeline.yaml” “on:push” event, and click on the “test image” job as seen below:

Expand the [anchor-24]#“Test image” job-step labeled “Run pytest inside container” to see the result of the step which tests the docker image as seen below:

The result will be as follows (You may have to scroll down to see the result):

Navigate to Docker Hub, and check that the image has been pushed.
https://hub.docker.com/repositories/<your_docker_hub_username>;

Click on “Repositories” in the main menu to verify the image “<your_dockerhub_username/my_app>” exists in Docker Hub as seen below:

Congratulations, you have completed an end-to-end pipeline.

You can choose to complete the optional challenge, or skip and move onto the CleanUp section.

Open a new or existing terminal session

Navigate to the working folder “/home/wasadmin/Works/github-actions-lab9".

Log in to Docker Hub using your Docker Hub username and password/token , replacing <DOCKERHUB_USERNAME> and <DOCKERHUB_TOKEN> with your actual Docker Hub credentials using the command-syntax below:

docker login --username <DOCKERHUB_USERNAME> --password <DOCKERHUB_TOKEN>

Pull the Docker image from Docker Hub, replacing <DOCKERHUB_USERNAME>/my_app with the name of your Docker Hub repository using the command-syntax below:

docker pull <DOCKERHUB_USERNAME>/my_app:latest

Start a Docker container based on the pulled image:

docker run -d --name my_app -p 5001:5000 <DOCKERHUB_USERNAME>/my_app:latest

This command starts a container named app-container and maps port 5001 on your local machine to port 5000 inside the container.

Open a web browser window to access the running application using the following URL:
http://localhost:5001

Test the simple functionality of the application running in the Docker container.

Once you are happy, stop and remove the container once you have finished using these commands:

docker stop my_app
docker rm my_app

By following these steps above, you can pull the Docker image from Docker Hub and run the application locally using your image created by the pipeline.

This allows you to test the functionality of the application in an environment similar to the production environment.

Close all Terminal sessions, Open Web Browser windows and VSCode windows.

Open a new Terminal session using the Application’s menu located at the top of the Ubuntu Desktop, as shown below:

Create a new working directory for “lab10” using the following command:

mkdir -p /home/wasadmin/Works/lab10

Navigate to the newly created directory “/home/wasadmin/Works/lab10” using the “cd” command:

cd /home/wasadmin/Works/lab10

Confirm you are in the “/home/wasadmin/Works/lab10” directory using the “Print Working Directory (pwd)” command:

pwd

Result:

/home/wasadmin/Works/lab10

Copy the required template lab-files into the current directory by issuing the following command:

cp -R /home/wasadmin/Student_Templates/lab10/* .

Validate that you have copied all the template files correctly using the “tree” command as follows:

tree

The result will be the same as below:

.
├── MyDBProject
│   ├── app.py
│   ├── database.db
│   ├── database_wrapper_test.py
│   ├── run_app.sh
│   ├── run_coverage.sh
│   ├── gen_html_report.sh
│   └── templates
│   ├── customers.html
│   └── index.html
└── MyLoginProject
├── README.md
├── login_app.py
├── login_app_fixed.py
└── templates
├── index.html
└── login.html

4 directories, 13 files

We are now ready to starting the next part, which demonstrates how to initiate Vulnerability Scanning using Bandit.

Navigate to the “MyLoginProject” directory using:

cd ~/Works/lab10/MyLoginProject

Launch VSCode an automatically open the “login_app.py” file using the command-line tool as follows:

code login_app.py

The file’s contents will be displayed as follows:

Understanding the code:

This app (“login_app.py”) sets up a simple Flask web application that supports a home page and a login functionality.

Once you have finished reading “login_app.py”, close and exit using File > Exit in the VSCode menu.

Using your Existing open Terminal session, create a new virtual environment called “lab10” using “pyenv” and activate using the following commands:

pyenv virtualenv 3.10.7 lab10
pyenv activate lab10

Install the Bandit and Flask dependencies using issuing the following commands one after another:

pip install Flask==2.3.2
pip install bandit==1.7.5

To identify the default tests Bandit utilizes to scan for vulnerabilities, execute the following command:

bandit --help

The result will be a list of vulnerability tests as seen below in a the redacted example of the output:

The following tests were discovered and loaded:
-----------------------------------------------
        B101    assert_used
        B102    exec_used
        B103    set_bad_file_permissions
        B104    hardcoded_bind_all_interfaces
        B105    hardcoded_password_string
        B106    hardcoded_password_funcarg
        B107    hardcoded_password_default
        B108    hardcoded_tmp_directory
        <REDACTED for brevity>

Running a vulnerability scan on your Flask application using Bandit allows you to identify potential security issues in your Python code.

Run the following command to start the analysis:

bandit login_app.py

The result will be similar to the example output below:

Interpreting the Vulnerability Scan Results

After executing the vulnerability scan command Bandit provides a detailed report of its findings. The report includes information about the line number, issues identified, severity level, and confidence level of each discovered security issue.

Looking at the output (below) more closely, we can see that there are two vulnerabilities. One vulnerability marked as Severity=Low (Blue), and the other is marked as Severity-High (Red).

In the image above we can see that the details of each vulnerability. Each vulnerability has two links which to background and/or root causes of how they may be related to generic or specific known vulnerabilities. The pages the links refer to also offer recommendations of how these vulnerabilities may be fixed.

The first link is to a related Common Weakness Enumeration (CWE).

CWE is a community-developed list of software and hardware weakness types. It serves as a common language, a measuring stick for security tools, and as a baseline for weakness identification, mitigation, and prevention efforts.

To look up the HIGH severity’s CWE, Open a New Browser Window by launching Chrome using the Applications menu as shown below:

Navigate to the URL:
https://cwe.mitre.org/data/definitions/94.html

The resulting loaded page gives details of this vulnerability as per the example below:

The second Link is to a Bandit specific site which discusses the finer details of the Bandit Vulnerability code “b201”.

To look up the Bandit “b201” code, Open a New Browser Tab/Window and navigate to the following URL:
https://bandit.readthedocs.io/en/1.7.5/plugins/b201_flask_debug_true.html

When the page is loaded, you will see the “b201” details page as per the image below:

To look up the LOW severity’s CWE, Open a New Browser Tab/Window and navigate to the URL:
https://cwe.mitre.org/data/definitions/259.html

The result will be a page that gives details of this vulnerability as per the example below:

To look up the Bandit “b105” code, Open a New Browser Tab/Window and navigate to the following URL:
https://bandit.readthedocs.io/en/1.7.5/plugins/b105_hardcoded_password_string.html

You will see the “b105” details page as per the image below:

Using the intelligence gleaned from the above URL’s we can fix the code.

To save time, we have made the required changes to “login_app.py”, in a file called “login_app_fixed.py”. These changes are on line 7 and line 31.

Open up the “login_app_fixed.py” using the VSCode command-line tool:

code login_app_fixed.py

Read through the code, noting the following changes which are as follows:

Line 7 previous:

hardcoded_password = "mysecretpassword"

Changed to:

hardcoded_password = os.environ.get('PASSWORD') #Fix for B105: hardcoded_password_string: Harcoded variable. Now uses environment variable.

Line 31 previous:

app.run(debug=True)

Changed to:

app.run(debug=False)

We can see the entire contents of the “login_app_fixed.py” file below:

Now that we have reviewed the “patched” code, lets see if the vulnerabilities have been fixed?

Close the “login_app_fixed.py” file using the File > Exit menu of VSCode.

In the current terminal session, run the following Bandit, but this time using the “login_app_fixed.py” file:

bandit login_app_fixed.py

The result will be reported as follows:

[main]	INFO	profile include tests: None
[main]	INFO	profile exclude tests: None
[main]	INFO	cli include tests: None
[main]	INFO	cli exclude tests: None
[main]	INFO	running on Python 3.10.7
Run started:2023-07-11 19:28:49.311253

Test results:
	No issues identified.

Code scanned:
	Total lines of code: 25
	Total lines skipped (#nosec): 0

Run metrics:
	Total issues (by severity):
		Undefined: 0
		Low: 0
		Medium: 0
		High: 0
	Total issues (by confidence):
		Undefined: 0
		Low: 0
		Medium: 0
		High: 0
Files skipped (0):

We can from the output above, there are no Vulnerabilities in the “login_app_fixed.py” file according to Bandit.

Optionally: If you are interested to run the Flask app, then use the following commands:

set PASSWORD=mysecretpassword
python login_app_fixed.py

In this section of the lab, we focused on enhancing the security of our Python code. We achieved this by running Bandit on our code and interpreting the scan results to identify potential vulnerabilities. Necessary changes were made to fix the identified issues.

By using Bandit, we gained practical experience in improving the security of our Python projects.

General Tips when using Vulnerability Scanning Tools:

Carefully review generated reports, prioritizing issues with high severity and confidence.

Take note of the provided information to understand the nature of each vulnerability.

Consider the recommendations provided by the tools and take necessary actions to mitigate the identified vulnerabilities.

In the currently open terminal session, navigate to the “/home/wasadmin/Works/lab10/MyDBProject” using the following command:

cd /home/wasadmin/Works/lab10/MyDBProject

Launch VSCode and open the “app.py” file command-line tool as follows:

code app.py

Have a read through the “app.py” code. Below is a brief outline of the key elements.

Explanation of “app.py”

The “app.py” is a Flask application that serves as a simple example of a basic customer management system. The application uses SQLAlchemy, an ORM (Object-Relational Mapper) for Python, for interacting with a SQLite database.

For interest sake, the apps key features are briefly outlined below:

Close the “app.py” file using File > Exit in the VSCode menu.

Lets have a quick look at the unit-test called “database_wrapper_test.py”, which we will evaluate using “Coverage.py”, to see how much code the test covers.

Launch VSCode and open the “database_wrapper_test.py” using the command-line tool as follows:

code database_wrapper_test.py

The contents of the “database_wrapper_test.py” unit-test can be seen in the image that follows:

As we can see in the image above, this unit-test case tests the four methods of the “DatabaseWrapper” class:

Once you have finished reading the code, close the “database_wrapper_test.py” using the File > Exit menu of VSCode.

Using the same Terminal Session, install “Coverage.py”, “Flask” and “SQLAlchemy”, execute the following commands:

pip install coverage==7.2.7
pip install Flask==2.3.2
pip install Flask-SQLAlchemy==3.0.5

To measure the code coverage of your unit tests using “Coverage.py”, use the following command:

coverage run -m unittest discover

As a result a binary file called “.coverage” will be created.

Use the following command to verify that “.coverage” file was generated:

ls .coverage

the result is:

.coverage

The binary “.coverage” file is generated by the “Coverage.py” tool after you run your tests under coverage. It’s a data file that contains the detailed coverage information for each file in your project that was exercised during the test run.

Coverage data includes:

Use the “cat” command to list the contents of “run_coverage.sh”:

cat run_coverage.sh

the resulting contents of “run_coverage.sh” is displayed below:

#!/bin/bash
coverage run --source=. -m unittest discover -p '*_test.py' && coverage report --omit=app.py

Explanation:

This command is running unit tests with coverage in Python and then generating a coverage report. The command then uses the “Coverage.py” tool to measure code coverage of Python programs.

Here’s a breakdown of what each part of the command does:

coverage run -source=.

This part of the command runs your Python program under coverage. The “--source=.`”option tells “Coverage.py” to only measure coverage for Python files in the current directory (“.”) and its subdirectories.

-m unittest discover -p '*_test.py'

This part is a set of options for the “coverage run” command. The “-m unittest discover” command tells Python to run the unittest module’s test discovery system, which will discover and run test files. The “-p '*_test.py'” option tells the test discovery system to only discover files that match the pattern “*_test.py” (i.e., any Python file whose name ends with “_test.py”).

&&

This is a shell operator that tells the shell to execute the second command only if the first command completed successfully. If the first command fails (i.e., if any of the unit tests fail), then the second command will not be run.

coverage report –omit=app.py

This part of the command generates a coverage report. The “--omit=app.py” option tells “coverage.py” to omit the “app.py” file when generating the report. This means that the report will not include coverage data for “app.py”.

So, in summary, this command will discover and run all unit tests in Python files that end with “_test.py”, measure the code coverage of these tests for all Python files in the current directory and its subdirectories, and then generate a coverage report that omits “app.py”. If any of the unit tests fail, then the coverage report will not be generated.

To generate a code coverage report using “Coverage.py”, issue these two commands to make the script executable, and then run the script:

chmod +x run_coverage.sh
./run_coverage.sh

The result wil be as similar out as follows:

----------------------------------------------------------------------
----------------------------------------------------------------------
Ran 4 tests in 0.139s

OK
Name                       Stmts   Miss  Cover
----------------------------------------------
database_wrapper_test.py      43      1    98%
----------------------------------------------
TOTAL                         43      1    98%

The report provides information about the number of statements (“Stmts”), the number of missed statements (“Miss”), and the coverage percentage (“Cover”) for each file.

It is also possible to generate html-based reports.

Similarly, to simplify running the correct commands to generate an HTML coverage report, using the data within the “.coverage” file, we have created a bash-script called “gen_html_report.sh”

Use the “cat” command to list the contents of “run_coverage.sh”:

cat gen_html_report.sh

Resulting contents of “gen_html_report.sh” is displayed as follows:

#!/bin/bash
coverage run --source=. -m unittest discover -p '*_test.py' && coverage html --omit=app.py

To generate a code coverage HTML report using “Coverage.py”, issue these two commands to make the script executable, and then run the script:

chmod +x gen_html_report.sh
./gen_html_report.sh

The resulting output is as follows:

----------------------------------------------------------------------
Ran 4 tests in 0.140s

OK
Wrote HTML report to htmlcov/index.htm

Double-click on the Ubuntu Desktop Home icon, or use the Ubuntu Application menu to launch the File-Explorer app (Files) as shown in the two options below:

Navigate through the file-system to locate the report (index.html) which is in a folder called “htmlcov” right click on it and select “Open with Google Chrome”, which is located in “Home/Works/lab10/MyDBProject/htmlcov” as seen below:

Click on the “database_wrapper_test.py” link inside “index.html” to open the details page as seen below:

The resulting page displays a detailed coverage report for the “database_wrapper_test.py” unit test, which contains coverage information very similar to the image below:

Scroll down, and take a look at the report details.

We can see the Unit Test is reported as covering 98% of the code.

By following and completing this section of the lab, you learned how to use “Coverage.py” to measure code coverage for your unit tests.

Code coverage analysis helps you identify areas of your code that require more testing and ensures better overall quality and reliability of your software.

Well done!, The lab is now complete.

Deactivate the “pyevn” virtual environment in the Terminal where you have been doing the work above using the following command (run it twice):

pyenv deactivate lab10

Result:

yenv-virtualenv: no virtualenv has been activated.

Close all open Terminal sessions, and close all open application windows (e.g. VSCode, Chrome, etc).

Examine the design of a monolithic car rental application where all functionalities are integrated within a single codebase and deployed as a single unit.

The second is an application design leveraging microservcies, with a high-level architecture that could look like Figure 2, below.

Investigate a microservices-based car rental application where functionalities are modularized into independent services, communicating with each other through APIs.

Fig 1. Application Architecture 1: Traditional Enterprise Monolithic Architecture Example.

Fig. 2 Application Architecture 2: Microservices-based Architecture Example.

Compare the Monolith Application Architecture 1 (Fig.1) with the Microservices Application Architecture 2 (Fig.2), and identify some of the differences.

What kind of Quality of Service properties we gain / lose by going from Architecture 1 to Architecture 2?

Which type of architecture more easily support scalability?

What would be involved if you need to change a single file/component in the app code for Architecture 1 vs Architecture 2?

In which of the architectures do you need to have more powerful computers? Is it about CPU, RAM, or both?

You need to recycle the machines hosting the applications. Which architecture will have a shorter application start up time?

Consider the following statement:

"Since my application operates in its unique runtime environment, frequently within a container or a type of virtual machine, I can obtain robust process isolation."

Does this statement correspond to the concept of microservices? If so, is it advocating for or against its usage?

Reflect on this assertion:

"Different services' change cycles can be effectively decoupled, allowing Service A to be re-deployed without influencing Service B."

Does this pertain to the microservices architectural pattern? If so, is this an argument in favor or against its implementation?

Consider the following statement:

"I am responsible for managing the performance overhead associated with inter-process communication,"

Is it connected with microservices architecture? If so, does it indicate a reason for or against adopting microservices?

Evaluate this assertion:

"Deployment cycles and developer productivity are enhanced due to the smaller scope of each service."

Is this relevant to the concept of microservices? If so, does it constitute a supporting argument for or against its adoption?

Reflect on this statement:

"This type of application architecture enables scalability on a per service or per tier basis."

Is it related to the microservices architecture? If so, does it favor or oppose the adoption of microservices?

Consider this statement:

"My application exhibits outstanding performance and quick service interactions while maintaining a compact security perimeter."

Is this statement linked to the microservices architecture? If so, is it advocating for or against the use of microservices?

Reflect on the following assertion:

"The significant operational overhead, including meticulously coordinated deployment and distributed monitoring, results from the increased number of individual components."

Is this statement relevant to microservices architecture? If yes, does it argue for or against the use of microservices?

Evaluate the following statement:

"My application consolidates all necessary services in a single location, deploying them via a unified archive. The application adheres to standard SOA principles, with services corresponding to specific business capabilities and accessible through a well-defined WSDL-based web service interface."

Is this related to the microservices architectural pattern? If so, is it an argument in favor or against its implementation?

Consider this statement:

"Now, it’s more like a nanoservice, offering increased granularity and modularity. Isn’t that impressive?"

Does this pertain to microservices architecture? If so, does this present an argument in favor or against its adoption?

Reflect on this statement:

"Smaller development teams can be allocated to create and manage individual services, leading to quicker onboarding and development cycles."

Does this statement correspond to the microservices architecture? If so, is it advocating for or against its usage?

Evaluate the following statement:

"With this architectural design, any state must be stored in a dependable external service, like a caching service."

Is this relevant to microservices? If so, does it constitute a supporting argument for or against its adoption?